/**
 * 公共方法 封装
 */
const COMMONFUNCTION = function () { }
COMMONFUNCTION.prototype = {
  /**
   * 获取业主数据
   */
  getOwnerData(params, fn) {
    params.access_token = $constant.urlParams.access_token
    if (this.isNull(params.access_token)) {
      return
    }
    const urlObj = this.getCurPathParam(false); // 不编码
    params.access_token = urlObj.access_token;
    
    // debugger
    $comApi.getOwnerData(params).then(res => {
      const data = res.data.userinfo || {}
      const personal = data.personal || {}
      const base = data.base || {}
      // debugger
      const userData = {
        phone: personal.mobile,
        name: base.nickname
      }
      // $com.setSession('OwnerData', userData);
      // debugger
      initOwnerData(userData); // 重置业主信息
      if (fn) {
        fn(res)
      }
    })
  },
  /**
   * 获取工单状态，根据物业和地产整合
   */
  getOrderStatus(stauts) {
    let arr = [];
    // isProperty 1.地产 2.物业
    let isProperty = $constant.isProperty
    if (isProperty === 1) {
      arr = [
        { value: 1, text: '建单' },
        { value: 2, text: '待分派' },
        { value: 3, text: '待处理' },
        { value: 4, text: '待评价' },
        { value: 5, text: '待回访' },
        { value: 6, text: '已完成' },
        { value: 7, text: '延时申请' },
        { value: 8, text: '申请关闭' },
        { value: 9, text: '驳回' },
        { value: 10, text: '已关闭' },
        // { value: 11, text: '草稿' }
      ]

    } else if (isProperty === 2) {
      arr = [
        { value: 1, text: '建单' },
        { value: 2, text: '待分派' },
        { value: 3, text: '待处理' },
        { value: 4, text: '正在处理' },
        { value: 5, text: '待评价' },
        { value: 6, text: '回访' },
        { value: 7, text: '不回访' },
        { value: 8, text: '已完成' },
        { value: 9, text: '延时申请' },
        { value: 10, text: '申请关闭' },
        { value: 11, text: '驳回' },
        { value: 12, text: '已关闭' },
        // { value: 13, text: '草稿' },
        { value: 14, text: '已关闭' }
      ]
    }
    let statusObj = {}
    // debugger
    stauts = Number(stauts);
    arr.some(item => {
      if (item.value === stauts) {
        statusObj = item
        return true
      }
    });
    return statusObj;
  },
  /**
   * 复制对象公共属性的值
   * @param {Object} obj1 拷贝的对象
   * @param {Object} obj2 被拷贝的对象
   */
  copyObjComVal(obj1, obj2) {
    // debugger
    if (this.isNull(obj1) && this.isNull(obj2)) {
      return {}
    }
    // debugger
    // let val = ''
    for (let key in obj1) {
      if (key && obj2.hasOwnProperty(key)) {
        obj1[key] = obj2[key]
      }
    }
    return obj1
  },
  /**
 * 对象，深拷贝
 * @param {Object} obj
 */
  deepCloneObj(data) {
    const type = this.getType(data)
    let obj
    if (type === 'array') {
      obj = []
    } else if (type === 'object') {
      obj = {}
    } else {
      return data
    }
    if (type === 'array') {
      for (let i = 0, len = data.length; i < len; i++) {
        obj.push(this.deepCloneObj(data[i]))
      }
    } else if (type === 'object') {
      for (const key in data) {
        if (data.hasOwnProperty(key)) {
          obj[key] = this.deepCloneObj(data[key])
        }
      }
    }
    return obj
  },
  /**
   * 对象，浅拷贝
   * @param {Object} obj
   */
  easyCloneObj(obj) {
    const newObj = {}
    for (const i in obj) {
      if (i && obj.hasOwnProperty(i)) {
        newObj[i] = obj[i]
      }
    }
    return newObj
  },
  /**
   * 获取对象属性类型
   * @param e
   * @returns {string}
   */
  getType(e) {
    if (e == null) {
      return ''
    }
    if (e.constructor === Array) {
      return 'array'
    } else if (e.constructor === Object) {
      return 'object'
    } else if (e.constructor === String) {
      return 'string'
    } else if (e.constructor === Number) {
      return 'number'
    } else if (e.constructor === Boolean) {
      return 'boolean'
    }
    return ''
  },
  /**
   * 设置缓存
   * @param key
   * @param value
   */
  setSession(key, value) {
    // debugger
    return new Promise((resolve, reject) => {
      try {
        window.sessionStorage.setItem(key, JSON.stringify(value))
        resolve()
      } catch (e) {
        console.error('setSession 错误')
        reject('setSession 错误')
      }
    })
  },
  /**
   * 获取缓存
   * @param key
   */
  getSession(key) {
    const item = window.sessionStorage.getItem(key)
    if (this.isNull(item)) {
      return ''
    }
    return JSON.parse(window.sessionStorage.getItem(key))
  },
  /**
   * 判断是否为空
   */
  isNull: function (val) {
    if (val instanceof Array) {
      if (val.length === 0) return true
    } else if (val instanceof Object) {
      if (JSON.stringify(val) === '{}') return true
    } else {
      if (val === 'null' || val == null || val === 'undefined' || val === undefined || val === '') return true
      return false
    }
    return false
  },
  /**
   * 清除字符串前后空格
   * @param {String} str
   */
  trim(str) { // 去字符串首尾空格
    // debugger
    if (typeof (str) === 'string') {
      str = str.replace(/(^\s*)|(\s*)$/g, '')
    }
    return str
  },
  /**
   * 讲json格式转为字符拼接，类似get请求带参
   * @param {Object} data
   */
  paramTurnBody(data) {
    if (this.isNull(data)) return null
    const arr = []
    for (const key in data) {
      if (key && data.hasOwnProperty(key)) {
        const val = data[key]
        if (!this.isNull(data[key])) {
          // val = '""'
          arr.push(key + '=' + val)
        }
      }
    }
    const str = arr.join('&')
    return str
  },
  /**
   * 防抖，在频繁触发某些事件，导致大量的计算或者非常消耗资源的操作的时候，防抖可以强制在一段连续的时间内只执行一次
   * */
  debounce(fn, delay) {
    // console.log('防抖1')
    const _delay = delay || 200
    let timer
    return function () {
      // console.log('防抖2')
      const th = this
      const args = arguments
      if (timer) {
        clearTimeout(timer)
      }
      timer = setTimeout(function () {
        timer = null
        fn.apply(th, args)
        // console.log('防抖3')
      }, _delay)
    }
  },
  /**
   * 函数节流，指定時間內只執行一次
   * @param {Funtion} fn 回调函数
   * @param {Number} interval
   */
  throttle(fn, interval = 300) {
    return function () {
      console.log('throttle1')
      if (fn.isThrottle) return
      console.log('throttle2')
      fn.isThrottle = true
      fn.apply(this, arguments)
      setTimeout(() => {
        console.log('throttle3')
        fn.isThrottle = false
        // store.dispatch('sys/UpdateIsTransition', false) // 启动页面切换转场
      }, interval)
    }
  },
  /**
   * 通过数组键值删除元素
   * @param {Array} arr 数组
   * @param {String} key 匹配的键
   * @param {String} val 匹配的值
   */
  removeByKey(arr, key, val) {
    const index = this.findKey(arr, key, val)
    if (index > -1) {
      arr.splice(index, 1)
    }
  },
  /**
   * 返回数组匹配到的索引
   * @param {Array} arr 数组
   * @param {String} key 匹配的键
   * @param {String} val 匹配的值
   * @return {Number} index 返回匹配到的索引
   */
  findKey(arr, key, val) {
    for (let i = 0; i < arr.length; i++) {
      if (arr[i][key] === val) {
        return i
      }
    }
    return -1
  },
  /**
   * 查找父元素
   * @param {Object} child 目标dom元素
   * @param {String} parentCls 父元素的class
   */
  getParentByClass(child, parentCls) {
    if (!child) {
      return child
    }
    const pNode = child.parentNode
    if (pNode.classList.length && pNode.classList.contains(parentCls)) {
      return pNode
    } else {
      return this.getParentByClass(pNode, parentCls)
    }
  },
  getRect(el) {
    if (el instanceof window.SVGElement) {
      const rect = el.getBoundingClientRect()
      return {
        top: rect.top,
        left: rect.left,
        width: rect.width,
        height: rect.height
      }
    } else {
      return {
        top: el.offsetTop,
        left: el.offsetLeft,
        width: el.offsetWidth,
        height: el.offsetHeight
      }
    }
  },
  /**
   * 获取url地址参数，并转成对象格式
   * @params {Boolean} isEncode 是否编码 默认true
   */
  getCurPathParam(isEncode) {
    isEncode = !!isEncode;
    let newObj = {}
    // let keyWordArr = ['access_token']; // 特殊关键字，特殊处理
    let url = location.search // 获取链接 #/...? 后的字符串，并组合成 json 格式
    if (isEncode) {
      url = decodeURIComponent(url)
    }
    // console.log('url:', url);
    // debugger
    if (url) {
      url = url.substr(1)
      const obj = url.split('&')
      // debugger
      let arr = []
      for (const paramStr of obj) {
        arr = paramStr.split('=');
        let key = arr[0];
        let val = arr[1];
        // if (keyWordArr.some(i => i === key)) {
        //   // debugger
        //   let firstIndex = paramStr.indexOf('=');
        //   val = paramStr.substr(firstIndex)
        // }
        newObj[key] = val
      }
    }
    return newObj
  },
  /**
   * 对象转url str
   * 只支持一级obj
  */
  obj2Str(obj) {
    let str = ''
    for (let key in obj) {
      if (key && obj.hasOwnProperty(key)) {
        let val = obj[key]
        if (this.checkChinese(val)) {
          val = encodeURIComponent(val)
        }
        str += '&' + key + '=' + val
      }
    }
    str = '?' + str.substr(1)
    return str
  },
  /**
   * 中文编码
   * @param {String} str 
   */
  checkChinese(str) {
    var reg = new RegExp("[\\u4E00-\\u9FFF]+", "g");
    let falg = false
    if (reg.test(str)) {
      flag = true
    }
    return falg
  }
}
// 公共方法 实例化
// const $com = new COMMONFUNCTION()
let $com = null
export default $com = new COMMONFUNCTION()
window.$com = $com;
// console.log('custom.js 运行完毕')